// 好了终于到了网上非常火热的 agent 这一块儿的知识了
// 单一 agent
/**
 * 一个 agent 往往能根据用户的问题做思考，然后去整合现有的工具资源，执行工具，并观察输出结果，
 * 根据当前输出结果和现有环境信息，决策下一步操作，当 llm 人物，问题已经被解决时
 * 输出最终答案
 */

// 多 agent。 现在还流行一个概念，多代理系统（MAS，Multi-Agent System）
/**
 * 通过多个固有角色的 agent，并且每个 agent 有独立的 memory 系统，有对应自己角色的标准人物处理流程，独立进行决策和执行
 * 一般多 Agents 系统是模拟人类真实的协作模式，例如我们以模拟软件公司工作流程的系统为例，系统内会包含 
 * 产品经理、架构师、项目经理、工程师和质量保证工程师等多个 agents，对应人类世界中不同的角色。
 */

// ========== SerpAPI Demo ==========
/**
 * SerpAPI 是一个提供搜索引擎结果的 API 服务，可以让 AI Agent 实时搜索互联网信息
 * 
 * 如何获取 API Key:
 * 1. 访问 https://serpapi.com/
 * 2. 注册账号（提供免费的 100 次搜索）
 * 3. 在 Dashboard 中获取 API Key
 * 4. 将 API Key 添加到 .env 文件：SERPAPI_API_KEY=your_api_key_here
 */

import { config } from "dotenv";
import { ChatOpenAI } from "@langchain/openai";
import { SerpAPI } from "@langchain/community/tools/serpapi";
import { AgentExecutor, createReactAgent } from "langchain/agents";
import { pull } from "langchain/hub";
import type { ChatPromptTemplate } from "@langchain/core/prompts";

await config();

// ========== 示例 1: 直接使用 SerpAPI 工具 ==========
async function testSerpAPIDirectly() {
  console.log("\n========== 示例 1: 直接使用 SerpAPI 工具 ==========\n");
  
  // 创建 SerpAPI 工具
  const serpAPI = new SerpAPI(process.env.SERPAPI_API_KEY, {
    location: "Beijing,Beijing,China",  // 搜索位置
    hl: "zh-cn",  // 语言
    gl: "cn",  // 国家/地区
  });

  // 直接调用工具进行搜索
  try {
    const result = await serpAPI.invoke("2024年巴黎奥运会中国金牌数");
    console.log("搜索结果：\n", result);
  } catch (error: any) {
    console.error("搜索失败：", error.message);
    console.log("\n提示：请确保在 .env 文件中配置了 SERPAPI_API_KEY");
    console.log("获取 API Key: https://serpapi.com/");
  }
}

// ========== 示例 2: 使用 Agent + SerpAPI ==========
async function testAgentWithSerpAPI() {
  console.log("\n========== 示例 2: 使用 Agent + SerpAPI ==========\n");

  // 初始化模型
  const model = new ChatOpenAI({
    modelName: "gpt-4",
    temperature: 0,
  });

  // 创建 SerpAPI 工具
  const serpAPI = new SerpAPI(process.env.SERPAPI_API_KEY, {
    location: "Beijing,Beijing,China",
    hl: "zh-cn",
    gl: "cn",
  });

  // 定义工具列表
  const tools = [serpAPI];

  try {
    // 从 LangChain Hub 拉取 ReAct prompt 模板
    // ReAct = Reasoning + Acting（推理 + 行动）
    const prompt = await pull<ChatPromptTemplate>("hwchase17/react");

    // 创建 ReAct Agent
    const agent = await createReactAgent({
      llm: model,
      tools,
      prompt,
    });

    // 创建 Agent Executor（执行器）
    const agentExecutor = new AgentExecutor({
      agent,
      tools,
      verbose: true,  // 显示详细的推理过程
      maxIterations: 3,  // 最大迭代次数
    });

    // 执行查询
    console.log("🤖 用户问题：今天的天气怎么样？北京明天会下雨吗？\n");
    const result = await agentExecutor.invoke({
      input: "今天北京的天气怎么样？明天会下雨吗？",
    });

    console.log("\n✅ 最终回答：\n", result.output);
  } catch (error: any) {
    console.error("Agent 执行失败：", error.message);
    console.log("\n提示：请确保在 .env 文件中配置了 SERPAPI_API_KEY");
  }
}

// ========== 示例 3: 自定义搜索工具 + Agent ==========
async function testCustomSearchAgent() {
  console.log("\n========== 示例 3: 多工具 Agent（SerpAPI + 计算器）==========\n");

  const model = new ChatOpenAI({
    modelName: "gpt-4",
    temperature: 0,
  });

  // 创建搜索工具
  const searchTool = new SerpAPI(process.env.SERPAPI_API_KEY, {
    location: "Beijing,Beijing,China",
    hl: "zh-cn",
    gl: "cn",
  });

  // 创建一个简单的计算器工具（自定义工具）
  const { tool } = await import("@langchain/core/tools");
  
  const calculatorTool = tool(
    async (input: string) => {
      try {
        // 简单的数学表达式计算
        const result = eval(input);
        return `计算结果：${result}`;
      } catch (error) {
        return "计算失败，请提供有效的数学表达式";
      }
    },
    {
      name: "calculator",
      description: "用于执行数学计算。输入应该是一个数学表达式，例如：'2 + 2' 或 '10 * 5'",
    }
  );

  const tools = [searchTool, calculatorTool];

  try {
    const prompt = await pull<ChatPromptTemplate>("hwchase17/react");
    const agent = await createReactAgent({
      llm: model,
      tools,
      prompt,
    });

    const agentExecutor = new AgentExecutor({
      agent,
      tools,
      verbose: true,
      maxIterations: 5,
    });

    console.log("🤖 用户问题：2024年巴黎奥运会中国获得了多少金牌？如果每块金牌价值1万美元，总价值是多少？\n");
    
    const result = await agentExecutor.invoke({
      input: "2024年巴黎奥运会中国获得了多少金牌？如果每块金牌价值1万美元，总价值是多少？",
    });

    console.log("\n✅ 最终回答：\n", result.output);
  } catch (error: any) {
    console.error("Agent 执行失败：", error.message);
  }
}

// ========== 执行 Demo ==========
async function main() {
  console.log("🚀 开始 SerpAPI Agent Demo\n");
  console.log("=" .repeat(60));

  // 检查 API Key
  if (!process.env.SERPAPI_API_KEY) {
    console.log("\n⚠️  警告：未找到 SERPAPI_API_KEY");
    console.log("\n请按以下步骤配置：");
    console.log("1. 访问 https://serpapi.com/ 注册账号");
    console.log("2. 在 Dashboard 获取 API Key（免费提供 100 次搜索）");
    console.log("3. 在 .env 文件中添加：SERPAPI_API_KEY=your_api_key_here\n");
    console.log("=" .repeat(60));
    return;
  }

  try {
    // 运行示例 1
    await testSerpAPIDirectly();
    
    // 运行示例 2
    // await testAgentWithSerpAPI();
    
    // 运行示例 3（需要更多时间和 token）
    // await testCustomSearchAgent();
  } catch (error: any) {
    console.error("\n❌ 执行出错：", error.message);
  }

  console.log("\n" + "=".repeat(60));
  console.log("✨ Demo 执行完成！");
}

main();

// ========== 免费搜索工具方案 ==========

// ========== 方案 1: 使用 DuckDuckGo (完全免费，推荐!) ==========
/**
 * DuckDuckGo 搜索是完全免费的，不需要任何 API Key
 * LangChain 已经内置了 DuckDuckGo 搜索工具
 */
import { useModel } from "../model";
async function testDuckDuckGoSearch() {
  console.log("\n========== 方案 1: DuckDuckGo 搜索（完全免费）==========\n");

    
  const { DuckDuckGoSearch } = await import("@langchain/community/tools/duckduckgo_search");
//   const { ChatOpenAI } = await import("@langchain/openai");
  const { AgentExecutor, createReactAgent } = await import("langchain/agents");
  const { pull } = await import("langchain/hub");

  try {
    // 创建 DuckDuckGo 搜索工具（无需 API Key！）
    const searchTool = new DuckDuckGoSearch({
      maxResults: 5,  // 返回最多5个结果
    });

    // const model = new ChatOpenAI({
    //   modelName: "gpt-4",
    //   temperature: 0,
    // });
    const model = useModel({temperature: 0});

    const tools = [searchTool];
    const prompt = await pull<ChatPromptTemplate>("hwchase17/react");
    const agent = await createReactAgent({
      llm: model,
      tools,
      prompt,
    });

    const agentExecutor = new AgentExecutor({
      agent,
      tools,
      verbose: true,
      maxIterations: 3,
    });

    console.log("🤖 用户问题：2024年诺贝尔物理学奖获得者是谁？\n");
    const result = await agentExecutor.invoke({
      input: "2024年诺贝尔物理学奖获得者是谁？",
    });

    console.log("\n✅ 最终回答：\n", result.output);
  } catch (error: any) {
    console.error("搜索失败：", error.message);
    console.log("\n提示：需要安装 duck-duck-scrape 包");
    console.log("运行: pnpm add duck-duck-scrape");
  }
}

// ========== 方案 2: 自定义 Bing 搜索工具 ==========
/**
 * 使用 Bing Web Search API
 * 需要 Azure 账号，但有免费层（1000次/月）
 * 注册地址：https://azure.microsoft.com/services/cognitive-services/bing-web-search-api/
 */
async function testCustomBingSearch() {
  console.log("\n========== 方案 2: 自定义 Bing 搜索工具 ==========\n");

  const { tool } = await import("@langchain/core/tools");
  const { z } = await import("zod");

  // 自定义 Bing 搜索工具
  const bingSearchTool = tool(
    async (query: string) => {
      const apiKey = process.env.BING_API_KEY;
      if (!apiKey) {
        return "错误：未配置 BING_API_KEY";
      }

      try {
        const response = await fetch(
          `https://api.bing.microsoft.com/v7.0/search?q=${encodeURIComponent(query)}&count=5`,
          {
            headers: {
              "Ocp-Apim-Subscription-Key": apiKey,
            },
          }
        );

        if (!response.ok) {
          return `搜索失败：${response.statusText}`;
        }

        const data = await response.json();
        
        // 提取搜索结果
        const results = data.webPages?.value?.slice(0, 5).map((item: any) => ({
          title: item.name,
          snippet: item.snippet,
          url: item.url,
        })) || [];

        return JSON.stringify(results, null, 2);
      } catch (error: any) {
        return `搜索出错：${error.message}`;
      }
    },
    {
      name: "bing_search",
      description: "使用 Bing 搜索引擎搜索最新信息。输入应该是搜索查询字符串。",
      schema: z.string().describe("搜索查询"),
    }
  );

  console.log("测试 Bing 搜索工具...");
  const result = await bingSearchTool.invoke("LangChain 是什么");
  console.log("搜索结果：\n", result);
}

// ========== 方案 3: 使用 Tavily Search (专为 AI Agent 设计) ==========
/**
 * Tavily 是专门为 AI Agent 设计的搜索 API
 * 有免费层（1000次/月）
 * 官网：https://tavily.com/
 */
async function testTavilySearch() {
  console.log("\n========== 方案 3: Tavily Search (专为 AI 设计) ==========\n");

  const { TavilySearchResults } = await import("@langchain/community/tools/tavily_search");
  
  try {
    // 创建 Tavily 搜索工具
    const searchTool = new TavilySearchResults({
      maxResults: 5,
      apiKey: process.env.TAVILY_API_KEY,
    });

    console.log("测试 Tavily 搜索...");
    const result = await searchTool.invoke("最新的 AI 技术进展");
    console.log("搜索结果：\n", result);
  } catch (error: any) {
    console.error("搜索失败：", error.message);
    console.log("\n提示：需要在 https://tavily.com/ 注册并获取 API Key");
    console.log("配置：在 .env 中添加 TAVILY_API_KEY=your_key");
  }
}

// ========== 方案 4: 简单的网页爬虫工具 ==========
/**
 * 自己实现一个简单的网页搜索和内容提取工具
 * 注意：这种方式可能违反某些网站的服务条款，仅供学习使用
 */
async function testCustomWebScraperTool() {
  console.log("\n========== 方案 4: 自定义网页爬虫工具 ==========\n");

  const { tool } = await import("@langchain/core/tools");
  const { z } = await import("zod");

  // 简单的 DuckDuckGo HTML 爬虫工具
  const webScraperTool = tool(
    async (query: string) => {
      try {
        // 使用 DuckDuckGo 的 HTML 版本（不需要 API）
        const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
        
        const response = await fetch(searchUrl, {
          headers: {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
          },
        });

        if (!response.ok) {
          return `搜索失败：${response.statusText}`;
        }

        const html = await response.text();
        
        // 简单的正则提取结果（生产环境应该使用专门的 HTML 解析库如 cheerio）
        const results: string[] = [];
        const snippetRegex = /<a class="result__snippet"[^>]*>(.*?)<\/a>/gs;
        let match;
        let count = 0;
        
        while ((match = snippetRegex.exec(html)) !== null && count < 5) {
          const snippet = match[1].replace(/<[^>]*>/g, "").trim();
          if (snippet) {
            results.push(snippet);
            count++;
          }
        }

        return results.length > 0 
          ? `搜索结果：\n${results.join("\n\n")}`
          : "未找到相关结果";
          
      } catch (error: any) {
        return `搜索出错：${error.message}`;
      }
    },
    {
      name: "web_search",
      description: "搜索网络上的最新信息。输入应该是搜索查询字符串。",
      schema: z.string().describe("搜索查询"),
    }
  );

  console.log("测试自定义爬虫工具...");
  const result = await webScraperTool.invoke("人工智能最新进展");
  console.log("搜索结果：\n", result);
}

// ========== 完整的免费 Agent 示例 ==========
async function testFreeSearchAgent() {
  console.log("\n========== 完整示例：使用免费搜索工具的 Agent ==========\n");

  // 方法1: 使用 DuckDuckGo (最推荐)
  try {
    const { DuckDuckGoSearch } = await import("@langchain/community/tools/duckduckgo_search");
    const { ChatOpenAI } = await import("@langchain/openai");
    const { AgentExecutor, createReactAgent } = await import("langchain/agents");
    const { pull } = await import("langchain/hub");

    const searchTool = new DuckDuckGoSearch({ maxResults: 5 });
    const model = new ChatOpenAI({ modelName: "gpt-4", temperature: 0 });
    const tools = [searchTool];
    
    const prompt = await pull<ChatPromptTemplate>("hwchase17/react");
    const agent = await createReactAgent({ llm: model, tools, prompt });
    const agentExecutor = new AgentExecutor({
      agent,
      tools,
      verbose: true,
      maxIterations: 3,
    });

    console.log("🤖 问题：今天是什么日期？最新的科技新闻有哪些？\n");
    const result = await agentExecutor.invoke({
      input: "今天是什么日期？告诉我最新的科技新闻",
    });

    console.log("\n✅ 最终回答：\n", result.output);
    console.log("\n💡 提示：DuckDuckGo 完全免费，无需任何 API Key！");
  } catch (error: any) {
    console.error("执行失败：", error.message);
    console.log("\n需要安装依赖：pnpm add duck-duck-scrape");
  }
}

// 取消注释来测试不同的方案
// testDuckDuckGoSearch();
// testCustomBingSearch();
// testTavilySearch();
// testCustomWebScraperTool();
// testFreeSearchAgent();

// ========== ReAct Agent 原理详解 ==========
/**
 * ReAct = Reasoning (推理) + Acting (行动)
 * 
 * 这是一个经典的 Agent 范式，由 Google Research 在 2022 年提出
 * 论文：ReAct: Synergizing Reasoning and Acting in Language Models
 * 
 * 核心思想：让 LLM 以"思考-行动-观察"的循环方式工作
 */

async function explainReActAgent() {
  console.log("\n========== ReAct Agent 工作原理详解 ==========\n");

  console.log(`
📚 ReAct 的工作流程：

1️⃣  **Thought (思考)**
   - LLM 分析当前问题和已有信息
   - 决定下一步要做什么
   
2️⃣  **Action (行动)**
   - 选择一个工具来执行
   - 生成工具的输入参数
   
3️⃣  **Observation (观察)**
   - 获取工具执行的结果
   - 将结果加入上下文
   
4️⃣  **循环或结束**
   - 如果问题解决 → 输出 Final Answer
   - 如果需要更多信息 → 回到步骤 1

═══════════════════════════════════════════

🎯 示例流程：

问题："2024年巴黎奥运会中国获得了多少金牌？如果每块金牌价值1万美元，总共价值多少？"

第 1 轮：
  Thought: 我需要先搜索中国在2024巴黎奥运会获得的金牌数
  Action: search
  Action Input: "2024巴黎奥运会中国金牌数"
  Observation: 中国获得了40枚金牌

第 2 轮：
  Thought: 我已经知道了金牌数是40枚，现在需要计算总价值
  Action: calculator
  Action Input: "40 * 10000"
  Observation: 400000

第 3 轮：
  Thought: 我现在有了所有信息，可以给出最终答案了
  Final Answer: 中国在2024年巴黎奥运会获得了40枚金牌，如果每块金牌价值1万美元，总价值为40万美元。

═══════════════════════════════════════════
  `);

  console.log("\n💻 createReactAgent 内部做了什么：\n");
  
  console.log(`
1. **构建 Prompt**
   - 系统提示：告诉 LLM 它是一个 Agent，可以使用工具
   - 工具描述：列出所有可用工具及其用途
   - 格式说明：定义 Thought/Action/Observation 的格式
   
2. **工具绑定**
   - 将工具列表与 LLM 关联
   - LLM 可以根据描述选择合适的工具
   
3. **创建执行循环**
   - 解析 LLM 输出，识别 Thought/Action/Action Input
   - 调用对应的工具
   - 将结果反馈给 LLM
   - 继续下一轮或输出最终答案
  `);
}

// ========== ReAct Prompt 模板示例 ==========
async function showReActPrompt() {
  console.log("\n========== ReAct Prompt 模板结构 ==========\n");
  
  const examplePrompt = `
Answer the following questions as best you can. You have access to the following tools:

{tools}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {input}
Thought: {agent_scratchpad}
  `;

  console.log("📝 标准 ReAct Prompt 模板：");
  console.log(examplePrompt);
  
  console.log("\n🔑 关键变量说明：");
  console.log("- {tools}: 所有可用工具的详细描述");
  console.log("- {tool_names}: 工具名称列表");
  console.log("- {input}: 用户的原始问题");
  console.log("- {agent_scratchpad}: Agent 的工作记录（思考和观察历史）");
}

// ========== 最新的 Agent 范式 ==========
/**
 * 除了 ReAct，现在还有很多新的 Agent 范式：
 * 
 * 1. **ReAct** (2022) - 推理+行动 ✅ LangChain 已支持
 * 2. **ReWOO** (2023) - 推理而不观察，先规划再执行
 * 3. **Reflexion** (2023) - 带反思机制，从错误中学习
 * 4. **Plan-and-Execute** - 先制定计划，再逐步执行
 * 5. **OpenAI Functions** - 使用 OpenAI 的 function calling
 * 6. **Structured Chat** - 结构化的多轮对话 Agent
 */

async function explainModernAgents() {
  console.log("\n========== 现代 Agent 范式对比 ==========\n");

  const agentComparison = `
┌─────────────────┬──────────────────┬──────────────────┬─────────────┐
│ Agent 类型      │ 核心特点         │ 适用场景         │ LangChain   │
├─────────────────┼──────────────────┼──────────────────┼─────────────┤
│ ReAct           │ 思考→行动→观察   │ 通用场景         │ ✅ 支持     │
│ Plan-Execute    │ 先计划后执行     │ 复杂多步任务     │ ✅ 支持     │
│ OpenAI Fns      │ 函数调用         │ OpenAI 模型      │ ✅ 支持     │
│ Structured Chat │ 结构化对话       │ 多轮对话         │ ✅ 支持     │
│ Self-Ask        │ 自问自答         │ 需要拆解的问题   │ ✅ 支持     │
│ ReWOO           │ 推理不观察       │ 降低 API 调用    │ ⚠️  部分    │
│ Reflexion       │ 带反思机制       │ 需要纠错的任务   │ ⚠️  实验中  │
└─────────────────┴──────────────────┴──────────────────┴─────────────┘

📊 详细说明：

1️⃣  **ReAct Agent** (最经典)
   优点：思路清晰，易于调试
   缺点：每步都要调用 LLM，成本较高
   使用：createReactAgent()

2️⃣  **Plan-and-Execute Agent** (适合复杂任务)
   优点：先制定完整计划，执行更有条理
   缺点：计划可能不灵活
   使用：createPlanAndExecuteAgent()

3️⃣  **OpenAI Functions Agent** (OpenAI 专属)
   优点：利用 OpenAI 的 function calling，更稳定
   缺点：仅限 OpenAI 模型
   使用：createOpenAIFunctionsAgent()

4️⃣  **Structured Chat Agent** (多轮对话)
   优点：支持复杂的多轮交互
   缺点：配置较复杂
   使用：createStructuredChatAgent()

5️⃣  **XML Agent** (最新，适合 Claude)
   优点：使用 XML 格式，Claude 表现更好
   缺点：格式要求严格
   使用：createXmlAgent()
  `;

  console.log(agentComparison);
}

// ========== 关于 CoAct（你问的新范式）==========
/**
 * 你说的可能是这几个概念之一：
 * 
 * 1. **CoAgent** (Collaborative Agent) - 多 Agent 协作
 * 2. **CoT (Chain-of-Thought)** - 思维链
 * 3. **CoT-SC** (Self-Consistency) - 自洽性思维链
 * 
 * 目前 LangChain 没有叫 "CoAct" 的官方 Agent 类型
 * 但有类似的协作概念：Multi-Agent Systems
 */

async function explainCollaborativeAgents() {
  console.log("\n========== 多 Agent 协作（可能是你说的 CoAct？）==========\n");

  console.log(`
🤝 Multi-Agent Collaboration (多 Agent 协作)

概念：多个 Agent 协同工作，每个 Agent 有自己的角色和职责

示例场景：软件开发团队模拟
  - 产品经理 Agent：分析需求
  - 架构师 Agent：设计系统
  - 工程师 Agent：编写代码
  - 测试 Agent：质量保证

流行框架：
  ✅ AutoGen (Microsoft)
  ✅ MetaGPT
  ✅ CrewAI
  ✅ LangGraph (LangChain 新推出的)

在 LangChain 中的实现：
  - 使用 LangGraph 创建多 Agent 工作流
  - 每个 Agent 是一个节点
  - Agent 之间通过消息传递协作
  `);

  console.log("\n💡 LangGraph 示例架构：\n");
  console.log(`
    ┌─────────────┐
    │   用户输入   │
    └──────┬──────┘
           │
    ┌──────▼──────┐
    │ 协调器 Agent │ ← 分配任务
    └──────┬──────┘
           │
     ┌─────┴─────┬─────────┬─────────┐
     │           │         │         │
┌────▼───┐  ┌───▼────┐ ┌──▼─────┐ ┌─▼──────┐
│ Agent1 │  │ Agent2 │ │ Agent3 │ │ Agent4 │
│ (搜索) │  │ (计算) │ │ (分析) │ │ (总结) │
└────┬───┘  └───┬────┘ └──┬─────┘ └─┬──────┘
     │          │         │         │
     └──────────┴─────────┴─────────┘
                │
         ┌──────▼───────┐
         │  最终输出    │
         └──────────────┘
  `);
}

// ========== 实战：不同 Agent 类型对比 ==========
async function compareAgentTypes() {
  console.log("\n========== 实战：使用不同类型的 Agent ==========\n");

  const { DuckDuckGoSearch } = await import("@langchain/community/tools/duckduckgo_search");
  const model = useModel({ temperature: 0 });
  const searchTool = new DuckDuckGoSearch({ maxResults: 3 });
  const tools = [searchTool];

  // 示例 1: ReAct Agent
  console.log("\n1️⃣  ReAct Agent:");
  try {
    const { createReactAgent } = await import("langchain/agents");
    const { pull } = await import("langchain/hub");
    const prompt = await pull<ChatPromptTemplate>("hwchase17/react");
    const reactAgent = await createReactAgent({ llm: model, tools, prompt });
    console.log("✅ ReAct Agent 创建成功");
    console.log("   特点：每步思考-行动-观察，思路清晰");
  } catch (error: any) {
    console.log("❌ 创建失败：", error.message);
  }

  // 示例 2: OpenAI Functions Agent (如果用 OpenAI)
  console.log("\n2️⃣  OpenAI Functions Agent:");
  try {
    const { createOpenAIFunctionsAgent } = await import("langchain/agents");
    const { ChatPromptTemplate } = await import("@langchain/core/prompts");
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", "You are a helpful assistant"],
      ["placeholder", "{chat_history}"],
      ["human", "{input}"],
      ["placeholder", "{agent_scratchpad}"],
    ]);
    const functionsAgent = await createOpenAIFunctionsAgent({
      llm: model,
      tools,
      prompt,
    });
    console.log("✅ OpenAI Functions Agent 创建成功");
    console.log("   特点：使用 OpenAI function calling，更稳定");
  } catch (error: any) {
    console.log("❌ 创建失败（可能需要 OpenAI 模型）：", error.message);
  }

  // 示例 3: Structured Chat Agent
  console.log("\n3️⃣  Structured Chat Agent:");
  try {
    const { createStructuredChatAgent } = await import("langchain/agents");
    const { pull } = await import("langchain/hub");
    const prompt = await pull<ChatPromptTemplate>("hwchase17/structured-chat-agent");
    const chatAgent = await createStructuredChatAgent({
      llm: model,
      tools,
      prompt,
    });
    console.log("✅ Structured Chat Agent 创建成功");
    console.log("   特点：支持复杂的多轮对话");
  } catch (error: any) {
    console.log("❌ 创建失败：", error.message);
  }
}

// 运行演示
// explainReActAgent();
// showReActPrompt();
// explainModernAgents();
// explainCollaborativeAgents();
// compareAgentTypes();

